home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 1 / PC Actual CD 01.iso / f1 / cimb.arj / EMS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-06  |  6.3 KB  |  315 lines
  1. /*==============================================================================
  2.  
  3. FICHERO: EMS.C
  4.  
  5. AUTOR: ANTONIO LADESA JURADO
  6.  
  7. FECHA: 24/6/94
  8.  
  9. DESCRIPCION:
  10.  
  11.     Fichero que contiene las estructuras, constantes, variables y funciones
  12.     internas y externas para la gestión de memoria EMS.
  13.  
  14. ==============================================================================*/
  15.  
  16.  
  17. /*---- MODULOS USADOS --------------------------------------------------------*/
  18.  
  19. #include <stdio.h>
  20. #include <io.h>
  21. #include <dos.h>
  22. #include <fcntl.h>
  23.  
  24. #include "ems.h"
  25.  
  26. /*---- VARIABLES LOCALES -----------------------------------------------------*/
  27.  
  28. static char *EMS_marco_pagina;
  29. static int EMS_paginas_totales;
  30. static int EMS_paginas_libres;
  31.  
  32. /*---- CODIFICACION DE LAS FUNCIONES OFRECIDAS -------------------------------*/
  33.  
  34.  
  35. /*---- FUNCION: extern int EMSmemIniciar(void) ---------------------------------
  36.  
  37.     Descripción:
  38.  
  39.         Esta función inicializa la memoria EMS.
  40.         Tambien actualiza el marco de página.
  41.  
  42.     Retorno:
  43.  
  44.         - 1 si la inicializa.
  45.         - 0 si no.
  46.  
  47. ---- CODIGO: -----------------------------------------------------------------*/
  48.  
  49. extern int EMSmemIniciar(void)
  50. {
  51. if(EMSmemDriver())
  52.     if(EMSHardware())
  53.         {
  54.         EMS_marco_pagina = EMSMarcoPagina();
  55.         return(1);
  56.         }
  57. return(0);
  58. }
  59.  
  60. /*---- FIN FUNCION -----------------------------------------------------------*/
  61.  
  62.  
  63. /*---- FUNCION: extern int EMSmemDriver(void) ----------------------------------
  64.  
  65.     Descripción:
  66.  
  67.         Esta función detecta si se ha instalado el driver de EMS.
  68.  
  69.     Retorno:
  70.  
  71.         - 1 si está instalado.
  72.         - 0 si no.
  73.  
  74. ---- CODIGO: -----------------------------------------------------------------*/
  75.  
  76. extern int EMSmemDriver(void)
  77. {
  78. int fichero;
  79. union REGS rg;
  80.  
  81. if((fichero=open("EMMXXXX0",O_RDONLY,&fichero))== -1)
  82.     return(0);
  83. rg.h.ah = 0x44;
  84. rg.h.al = 0x00;
  85. rg.x.bx = fichero;
  86. int86(0x21,&rg,&rg);
  87. close(fichero);
  88. if(rg.x.cflag)
  89.     return(0);
  90. if(rg.x.dx & 0x80)
  91.     return(1);
  92. else
  93.     return(0);
  94. }
  95.  
  96. /*---- FIN FUNCION -----------------------------------------------------------*/
  97.  
  98. /*---- FUNCION: extern int EMSHardware(void) -----------------------------------
  99.  
  100.     Descripción:
  101.  
  102.         Esta función detecta si existe una tarjeta EMS instalada
  103.         o un driver.
  104.  
  105.  
  106. ---- CODIGO: -----------------------------------------------------------------*/
  107.  
  108. extern int EMSHardware(void)
  109. {
  110. union REGS rg;
  111.  
  112. rg.h.ah=0x40;
  113. int86(0x67,&rg,&rg);
  114. if(rg.h.ah==0)
  115.     return(1);
  116. else
  117.     return(0);
  118. }
  119.  
  120. /*---- FIN FUNCION -----------------------------------------------------------*/
  121.  
  122.  
  123. /*---- FUNCION: extern int EMSmemTotal(void) -----------------------------------
  124.  
  125.     Descripción:
  126.  
  127.         Esta función devuelve el número total de páginas.
  128.  
  129.     Retorno:
  130.  
  131.         Número de páginas.
  132.  
  133. ---- CODIGO: -----------------------------------------------------------------*/
  134.  
  135. extern int EMSmemTotal(void)
  136. {
  137. union REGS rg;
  138.  
  139. rg.h.ah = 0x42;
  140. int86(0x67,&rg,&rg);
  141. if(rg.x.cflag)
  142.     return(-1);
  143. EMS_paginas_totales = rg.x.dx;
  144. return(EMS_paginas_totales);
  145. }
  146.  
  147. /*---- FIN FUNCION -----------------------------------------------------------*/
  148.  
  149.  
  150. /*---- FUNCION: extern int EMSmemLibre(void) -----------------------------------
  151.  
  152.     Descripción:
  153.  
  154.         Esta función devuelve el numero de paginas libres.
  155.  
  156.     Retorno:
  157.  
  158.         Número de páginas libres.
  159.  
  160. ---- CODIGO: -----------------------------------------------------------------*/
  161.  
  162. extern int EMSmemLibre(void)
  163. {
  164. union REGS rg;
  165.  
  166. rg.h.ah = 0x42;
  167. int86(0x67,&rg,&rg);
  168. if(rg.x.cflag)
  169.     return(-1);
  170. EMS_paginas_libres = rg.x.bx;
  171. return(EMS_paginas_libres);
  172. }
  173.  
  174. /*---- FIN FUNCION -----------------------------------------------------------*/
  175.  
  176.  
  177. /*---- FUNCION: extern char *EMSMarcoPagina(void) ------------------------------
  178.  
  179.     Descripción:
  180.  
  181.         Esta función devuelve el marco de página EMS.
  182.  
  183.     Retorno:
  184.  
  185.         Ventana EMS.
  186.  
  187. ---- CODIGO: -----------------------------------------------------------------*/
  188.  
  189. extern char *EMSMarcoPagina(void)
  190. {
  191. union REGS rg;
  192.  
  193. rg.h.ah=0x41;
  194. int86(0x67,&rg,&rg);
  195. if(rg.h.ah != 0)
  196.     return(NULL);
  197. else
  198.     return(MK_FP(rg.x.bx,0));
  199. }
  200.  
  201. /*---- FIN FUNCION -----------------------------------------------------------*/
  202.  
  203.  
  204. /*---- FUNCION: extern unsigned int EMSmemReservar(int n) ----------------------
  205.  
  206.     Descripción:
  207.  
  208.         Esta función reserva 1 o varias páginas de memoria EMS.
  209.  
  210.     Parámetros:
  211.  
  212.         n : número de páginas a reservar.
  213.  
  214. Retorno:
  215.  
  216.         - Gestor EMS.
  217.         - 0 si hubo error.
  218.  
  219. ---- CODIGO: -----------------------------------------------------------------*/
  220.  
  221. extern unsigned int EMSmemReservar(int n)
  222. {
  223. union REGS rg;
  224.  
  225. if(n > EMSmemLibre())
  226.     return(0);
  227. rg.h.ah = 0x43;
  228. rg.x.bx = n;
  229. int86(0x67,&rg,&rg);
  230. if(rg.h.ah)
  231.     return(0);
  232. else
  233.     {
  234.     EMSmemLibre();
  235.     return(rg.x.dx);
  236.     }
  237. }
  238.  
  239. /*---- FIN FUNCION -----------------------------------------------------------*/
  240.  
  241.  
  242. /*---- FUNCION: extern int EMSmemLiberar(unsigned int h) -----------------------
  243.  
  244.     Descripción:
  245.  
  246.         Esta función libera memoria EMS reservada anteriormente.
  247.  
  248.     Parámetros:
  249.  
  250.         unsigned int h : gestor de memoria EMS a liberar
  251.  
  252. Retorno:
  253.  
  254.         - 1 si liberó.
  255.         - 0 si hubo error.
  256.  
  257. ---- CODIGO: -----------------------------------------------------------------*/
  258.  
  259. extern int EMSmemLiberar(unsigned int h)
  260. {
  261. union REGS rg;
  262.  
  263. rg.h.ah=0x45;
  264. rg.x.dx=h;
  265. int86(0x67,&rg,&rg);
  266. if(rg.h.ah == 0)
  267.     {
  268.     EMSmemLibre();
  269.     return(1);
  270.     }
  271. else
  272.     return(0);
  273. }
  274.  
  275. /*---- FIN FUNCION -----------------------------------------------------------*/
  276.  
  277.  
  278. /*---- FUNCION: extern int EMSmemMapear(unsigned int h,           --------------
  279.                                                                                 int pagina_fisica,
  280.                                                                                 int pagina_logica)                                                                                ) -------------------
  281.  
  282.     Descripción:
  283.  
  284.         Esta función mapea pagina logica a pagina fisica.
  285.  
  286.     Parámetros:
  287.  
  288.         unsigned int h : gestor de memoria EMS
  289.         int pagina_fisica : página física
  290.         int pagina_logica : página lógica
  291.  
  292. Retorno:
  293.  
  294.         - 1 si hubo éxito.
  295.         - 0 si hubo error.
  296.  
  297. ---- CODIGO: -----------------------------------------------------------------*/
  298.  
  299.  
  300. int EMSmemMapear(unsigned int h,int pagina_fisica,int pagina_logica)
  301. {
  302. union REGS rg;
  303.  
  304. rg.h.ah = 0x44;
  305. rg.h.al = pagina_fisica;
  306. rg.x.bx = pagina_logica;
  307. rg.x.dx = h;
  308. int86(0x67,&rg,&rg);
  309. if(rg.h.ah != 0)
  310.     return(0);
  311. else
  312.     return(1);
  313. }
  314.  
  315. /*---- FIN FUNCION -----------------------------------------------------------*/